
define([
        'Util',
        'text!tpl/requirement/editRequirement.tpl',
        'text!tpl/requirement/taskAss.tpl',
        'select',
        'date',
        'form',
        'dialog',
        'jquery',
        'checkboxes',
        'validator',
        'loading',
        'radios',
        'cookie',
        'upload',
        'list',
        'inputTag',
        '../common/getPath',
        '../common/dateDiff',
        'comboSelect',
        '../requirement/fileList',
        '../common/dateFormat',

    ],
    function (Util, tpl,taskAss, Select, MyDate, Form, Dialog, $, Checkboxes, Validator, Loading,Radios, $cookie,Upload,List,inputTag, AjaxPath,computeDaysDelta,ComboSelect,fileList) {
        require(['style!css/style.css']);
        "use strict"
        //系统变量-定义该模块的根节点
        var $el = null;
        var _indexModule = null,
            tabParent = null,
            editReqData = null,
            editReqValidation = null,
            editTagListSelect = null,
            editLinksToSelect = null,
            editModuleListSelect = null,
            delFlag = false,
            reqAttachmentIdList = [],
            statusChangeSelect = null,
            tryPeopleChangeSelect= null,
            editSubTaskMomeValidor = null,
            editRequirementTable = null,
            editReqSubTaskLogTable = null,
            dialog = null,
            radios = null,
            editSprintsChangeSelect = null,
            editTagListSelectList = [],
            editPriStatusSelsect = null,
            editSubTaskAssSelect = null,
            editReqType = null,
            tryPeopleData = null,
            changeStatusVal = 1,
            editReqDataTplId = null,
            addSubTaskData = null,
            comboSelect = null,
            loadingConfig=null,
            moduleReqType = null,
            severityReq = null,
            findSprintsChangeSelect = null,
            relationToSelect = null,
            defectReason = null,
            defectstatusChangeSelect = null;
        //系统变量-构造函数
        var initialize = function(indexModule, options, tabItem) {
            reqAttachmentIdList = [];
            $el = $(tpl);
            _indexModule = indexModule;
            $(tabItem).on("tabActive", function() {
                tabItem.show(true); //刷新表单
            });
            createLoading();

            editReqData = options;
            editReqDataTplId = options.menuId;
            addSubTaskData = editReqData;
            tabParent = tabItem;
            eventInit();
            this.content = $el;
            getEditReqData();
            judgeRequireType();
        };
        //业务代码-事件初始化
        var eventInit = function() {
            $el.on('click', '.addRequireBtn', saveEditRequiretValidation);
            $el.on('click', '.btnBack', back);
            $el.on('click', '.t-list-title .tri', bindTableSwitch);
            $el.on('click', '.editReqNextStatus a', bindEditTaskNextStatus);
            $el.on('click', '.editReqTaskLogTab li', bindEditReqSubtaskLogTab);
            $el.on('click', '.taskAss', createReqAssDialog);
            $el.on('click', '.editReqTableAssBtn', createReqAssDialog);
            $el.on('click', '.editReqTableEditBtn', editSubTask);
            $el.on('click', '.viewSubTaskBtn', viewSubTask);
            $el.on('click', '.addSubTaskBtn', addSubTask);
            $el.on('click', '.editReqTaskAddMome', createReqMomeDialog);
        };

        var back = function() {
            tabParent.switchTab(editReqDataTplId);
            tabParent.destroy("editReqTab");
        };

        var switchTab = function(index) {
            $(".t-tabs-items li", $el).eq(index).trigger('click');
        };
        //初始化表单
        var formInit = function(){
            $("input[name='requireTitle']", $el).val(editReqData.requireTitle);
            $("#presentDepartment", $el).val(editReqData.presentDepartmentName);
            $("input[name='presentDepartment']", $el).val(editReqData.presentDepartment);
            $("input[name='likeMoreTime']", $el).val(editReqData.likeMoreTime);
             $("input[name='reallyUseTime']", $el).val(editReqData.reallyUseTime);
            $("textarea[name='describe']", $el).val(editReqData.describe);
            $(".editReqPosition", $el).html(editReqData.systemName);

            if(editReqData.changeStatus === '无'){
                changeStatusVal = 0;
            }else{
                changeStatusVal = 1;
            }
        };
        //新建子工作项
        var addSubTask = function(){
            tabParent.destroy("viewRequirementTab");

            tabParent.createTab({
                title: '新建子工作项',
                closeable: 1, //是否可以关闭 0false不可以|1true可以
                className: 'addSubTaskTab'
            });
            tabParent.switchTab('新建子工作项');
            addSubTaskData.menuId = editReqDataTplId;
            require(['js/requirement/addSubTask'], function(addSubTaskContent) {
                var result = new addSubTaskContent({}, addSubTaskData, tabParent);
                tabParent.content(result.content);
            });
        };
        //修改子工作项
        var editSubTask = function(e){
            tabParent.destroy("viewRequirementTab");

            tabParent.createTab({
                title: '修改子工作项',
                closeable: 1, //是否可以关闭 0false不可以|1true可以
                className: 'editSubTaskTab'
            });
            tabParent.switchTab('修改子工作项');

            var editTaskData = editRequirementTable.getSelected();
            editReqData.menuId = editReqDataTplId;

            require(['js/requirement/editSubTask'], function(editSubTaskContent) {
                var result = new editSubTaskContent({}, editTaskData, tabParent);
                tabParent.content(result.content);
            });
        };
        //查看工作项 或 任务
        var viewSubTask = function(e, data){
            tabParent.destroy("viewRequirementTab");

            var editReqData = data.data;
            editReqData.menuId = editReqDataTplId;
            tabParent.createTab({
                title: (editReqData.type===1 ? '查看工作项' : editReqData.type===2 ? '查看子工作项' : ''),
                closeable: 1, //是否可以关闭 0false不可以|1true可以
                className: (editReqData.type===1 ? 'viewRequirementTab' : editReqData.type===2 ? 'viewSubTaskTab' : '')
            });
            tabParent.switchTab(editReqData.type===1 ? '查看工作项' : editReqData.type===2 ? '查看子工作项' : '');

            if(editReqData.type===1){
                require(['js/requirement/viewRequirement'], function(viewSubTaskContent) {
                    var result = new viewSubTaskContent({}, editReqData, tabParent);
                    tabParent.content(result.content);
                });
            }else if(editReqData.type===2){
                require(['js/requirement/viewSubTask'], function(viewSubTaskContent) {
                    var result = new viewSubTaskContent({}, editReqData, tabParent);
                    tabParent.content(result.content);
                });
            }
        };
        //获取状态
        var getEditTaskNextStatus = function(statusId){
            if(editReqData.requireType === "4"){
                Util.ajax.getJson(AjaxPath.project + '/workFlows/getFLowActions?httpToken=devopsuseracount&modual=defect&type=defectStatus&flowFrom=' + statusId +'&systemId='+ editReqData.systemId, {}, function(result, isok){
                    if(result.returnCode==='0000'){
                        var str = "";
                        $(result.beans).each(function(index, item){
                            if(item.description === "" || item.description === null){
                                item.description = "&nbsp;";
                            }
                            str += '<a href="javascript:;" class="t-btn t-btn-white" data="'+ item.toValue +'">'+ item.description +'</a>';
                        })

                        $(".editReqNextStatus", $el).html(str);
                    }
                });

            }else{
                Util.ajax.getJson(AjaxPath.project + '/workFlows/getFLowActions?modual=require&type=requireStatus&flowFrom=' + statusId +'&systemId='+ editReqData.systemId, {}, function(result, isok){
                    if(result.returnCode==='0000'){
                        var str = "";
                        $(result.beans).each(function(index, item){
                            if(item.description === "" || item.description === null){
                                item.description = "&nbsp;";
                            }
                            str += '<a href="javascript:;" class="t-btn t-btn-white" data="'+ item.toValue +'">'+ item.description +'</a>';
                        })

                        $(".editReqNextStatus", $el).html(str);
                    }
                });
            }
        };
        //==//
        var bindEditTaskNextStatus = function(){
            var config = null;
            var data = {};
            data.id = editReqData.id;
            data.updater = $cookie.get("userId");
            data.type = 1;
            data.status = $(this).attr("data");
            Util.ajax.postJson(AjaxPath.demand + '/requires/status', JSON.stringify(data), function(result, isok){
                if (result.returnCode==="0000") {
                    config = {
                        mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                        title:'提示',
                        width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                        height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                        cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                        modal:true,
                        content: '<div style="text-align:center;margin-top:50px">修改状态成功</div>' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
                    };
                    dialog = new Dialog(config);
                    dialog.on('onclose',function(){
                        getEditTaskNextStatus(result.beans.status);
                        if(editReqData.requireType === "4"){
                            defectstatusChangeSelect.setValue('"' + result.beans.status + '"');
                        }else{
                            statusChangeSelect.setValue('"' + result.beans.status + '"');
                        }
                    });

                }else{
                    config = {
                        mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                        title:'提示',
                        width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                        height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                        cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                        modal:true,
                        content: '<div style="text-align:center;margin-top:50px">'+result.returnMessage+'</div>' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
                    };
                    dialog = new Dialog(config);
                }
            },'application/json')
        }
        //初始化下拉框
        var inSelect = function() {
            //工作项类型
            Util.ajax.getJson( AjaxPath.project+"/dropdown?modual=require&type=requireType", {}, function(result, isok){
                editReqType = new Select({
                    el:$("#requireType", $el),       //要绑定的容器
                    ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                        method:'GET'
                    },
                    label:'<i style="color:red;padding:2px;">*</i>类型:', //下拉框单元左侧label文本，可不配置
                    selectText:false,       //是否显示  ‘选择|清除’  模式
                    name:'requireType',    //下拉框单元右侧下拉框名称
                    disabled:false,     //组件是否被禁用
                    topOption:"请选择", //设置最顶部option的text属性
                    value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                    textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                    valueField:"key",//设置下拉框value，填写数据中对应的字段名
                    datas: result.beans,         //数据源
                    loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                    dataReady:function(){
                    }
                });
                editReqType.setValue('"'+editReqData.requireType+'"');
                editReqType.disabled();
            });
             //严重程度
            Util.ajax.getJson( AjaxPath.project+"/dropdown?modual=defect&type=importance", {}, function(result, isok){
                severityReq = new Select({
                    el:$("#severityReq", $el),       //要绑定的容器
                    ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                        method:'GET'
                    },
                    label:'<i style="color:red;padding:2px;">*</i>严重程度:', //下拉框单元左侧label文本，可不配置
                    selectText:false,       //是否显示  ‘选择|清除’  模式
                    name:'severity',     //下拉框单元右侧下拉框名称
                    disabled:false,     //组件是否被禁用
                    topOption:"请选择", //设置最顶部option的text属性
                    value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                    textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                    valueField:"key",//设置下拉框value，填写数据中对应的字段名
                    datas: result.beans,         //数据源
                    loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                    dataReady:function(){}
                });
                severityReq.setValue('"'+editReqData.importStatus+'"');
            });
            //发现迭代
            Util.ajax.getJson( AjaxPath.project+"/dropdown?modual=publish&type=sprints&systemId="+editReqData.systemId, {}, function(result, isok){
                findSprintsChangeSelect = new Select({
                    el:$("#findSprintList", $el),       //要绑定的容器
                    ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                        method:'GET'
                    },
                    label:'<i style="color:red;padding:2px;"></i>发现迭代:', //下拉框单元左侧label文本，可不配置
                    selectText:false,       //是否显示  ‘选择|清除’  模式
                    name:'discoverySprint',    //下拉框单元右侧下拉框名称
                    disabled:false,     //组件是否被禁用
                    topOption:"请选择", //设置最顶部option的text属性
                    value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                    textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                    valueField:"key",//设置下拉框value，填写数据中对应的字段名
                    datas: result.beans,         //数据源
                    loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                    dataReady:function(){
                    }
                });
                if(editReqData.discoverySprint === null){
                    findSprintsChangeSelect.setValue(0);
                }else{
                    findSprintsChangeSelect.setValue('"'+editReqData.discoverySprint+'"');
                }
            });
            //缺陷原因
            Util.ajax.getJson( AjaxPath.project + "/dropdown?modual=defect&type=defectReason", {}, function(result, isok){
                if(result.returnCode === "0000"){
                    result.returnCode = "0";
                    for(var i =0;i<result.beans.length;i++){
                        result.beans[i].name =  result.beans[i].value;
                        result.beans[i].value = result.beans[i].key;
                    }
                    result.beans.unshift({
                            "id":"0",
                            "name":"请选择"
                    })
                    result.beans = JSON.parse(JSON.stringify(result.beans));
                }
                defectReason = new ComboSelect({
                    el:$("#defectReason"),       
                    name:'defectReason',  
                    checked:"0",       
                    loadAtClick:false,
                    datas: result.beans   
                });
                defectReason.setValue(editReqData.defectReason)
            })
            //状态
            Util.ajax.getJson( AjaxPath.project+"/dropdown?modual=require&type=requireStatus&flowSwitch=true&systemId="+editReqData.systemId+"&flowFrom="+editReqData.status, {}, function(result, isok){
                statusChangeSelect = new Select({
                    el:$("#statusList", $el),       //要绑定的容器
                    ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                        method:'GET'
                    },
                    label:'<i style="color:red;padding:2px;">*</i>状态:', //下拉框单元左侧label文本，可不配置
                    selectText:false,       //是否显示  ‘选择|清除’  模式
                    name:'status',    //下拉框单元右侧下拉框名称
                    disabled:false,     //组件是否被禁用
                    topOption:"请选择", //设置最顶部option的text属性
                    value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                    textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                    valueField:"key",//设置下拉框value，填写数据中对应的字段名
                    datas: result.beans,         //数据源
                    loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                    dataReady:function(){
                    }
                });
                statusChangeSelect.setValue('"'+editReqData.status+'"');
            });
            //缺陷状态
            Util.ajax.getJson( AjaxPath.project+"/dropdown?modual=defect&type=defectStatus&flowSwitch=true&systemId="+editReqData.systemId+"&flowFrom="+editReqData.status, {}, function(result, isok){
                defectstatusChangeSelect = new Select({
                    el:$("#defectStatusList", $el),       //要绑定的容器
                    ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                        method:'GET'
                    },
                    label:'<i style="color:red;padding:2px;">*</i>状态:', //下拉框单元左侧label文本，可不配置
                    selectText:false,       //是否显示  ‘选择|清除’  模式
                    name:'status',    //下拉框单元右侧下拉框名称
                    disabled:false,     //组件是否被禁用
                    topOption:"请选择", //设置最顶部option的text属性
                    value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                    textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                    valueField:"key",//设置下拉框value，填写数据中对应的字段名
                    datas: result.beans,         //数据源
                    loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                    dataReady:function(){
                    }
                });
                defectstatusChangeSelect.setValue('"'+editReqData.status+'"');
            });
            //负责人
            Util.ajax.getJson( AjaxPath.project+"/dropdown?modual=project&type=userId&systemId="+editReqData.systemId, {}, function(result, isok){
                tryPeopleData = result.beans;
                if(result.returnCode === "0000"){
                    for(var i =0;i<result.beans.length;i++){
                        result.beans[i].name =  result.beans[i].value;
                        result.beans[i].value = result.beans[i].key;
                    }
                    result.beans.unshift({
                        "id":"0",
                        "name":"请选择",
                        "value":""
                    })
                    result.beans = JSON.parse(JSON.stringify(result.beans));
                }
                tryPeopleChangeSelect = new ComboSelect({
                    el:$("#tryPeopleList", $el),       //要绑定的容器
                    ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                        method:'GET'
                    },
                    // label:'<i style="color:red;padding:2px;">*</i>经办人:', //下拉框单元左侧label文本，可不配置
                    // selectText:false,       //是否显示  ‘选择|清除’  模式
                    checked:'0',  
                    name:'tryPeople',    //下拉框单元右侧下拉框名称
                    // disabled:false,     //组件是否被禁用
                    // topOption:"请选择", //设置最顶部option的text属性
                    value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                    textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                    valueField:"key",//设置下拉框value，填写数据中对应的字段名
                    datas: result.beans,         //数据源
                    loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                    // dataReady:function(){
                    // }
                });
                tryPeopleChangeSelect.setValue(editReqData.tryPeople);
                $("#tryPeopleList .combo-select select option").removeAttr("selected");
                $("#tryPeopleList .combo-select select option:first").attr("selected","selected").attr("disabled","");
                $("#tryPeopleList input[name='comboInput']").attr("placeholder", "请选择");
            });
            //提出人
            Util.ajax.getJson( AjaxPath.project+'/dropdown?modual=user&type=allUser', {}, function(result, isok){
                comboSelect = new ComboSelect({
                    el:'#presentPeople',       //要绑定的容器
                    name:'presentPeople',    //下拉框单元添加name属性
                    // checked:editReqData.presentPeople,        //默认选中
                    textField: 'value',
                    valueField: 'key',
                    loadAtClick:false,
                    datas: result.beans         //数据源与url模式可二选一
                });
                comboSelect.setValue(editReqData.presentPeople);
                comboSelect.change(function(e){
                    proposePerson(comboSelect.getSelected().key);
                });
            });


            //修复迭代
            Util.ajax.getJson( AjaxPath.project+"/dropdown?modual=publish&type=sprints&systemId="+editReqData.systemId, {}, function(result, isok){
                var str = null;
                if(editReqData.requireType === "4"){
                    str = "修复迭代:";
                }else {
                    str =  "迭代:";
                }
                editSprintsChangeSelect = new Select({
                    el:$("#sprintList", $el),       //要绑定的容器
                    ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                        method:'GET'
                    },
                    label: str, //下拉框单元左侧label文本，可不配置
                    selectText:false,       //是否显示  ‘选择|清除’  模式
                    name:'sprintId',    //下拉框单元右侧下拉框名称
                    disabled:false,     //组件是否被禁用
                    topOption:"请选择", //设置最顶部option的text属性
                    value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                    textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                    valueField:"key",//设置下拉框value，填写数据中对应的字段名
                    datas: result.beans,         //数据源
                    loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                    dataReady:function(){
                    }
                });
                editSprintsChangeSelect.setValue('"'+editReqData.sprint+'"');
            });

            //优先级
            Util.ajax.getJson( AjaxPath.project+"/dropdown?modual=require&type=priStatus", {}, function(result, isok){
                editPriStatusSelsect = new Select({
                    el:$("#priStatusList", $el),       //要绑定的容器
                    ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                        method:'GET'
                    },
                    label:'<i style="color:red;padding:2px;">*</i>优先级:', //下拉框单元左侧label文本，可不配置
                    selectText:false,       //是否显示  ‘选择|清除’  模式
                    name:'priStatus',    //下拉框单元右侧下拉框名称
                    disabled:false,     //组件是否被禁用
                    topOption:"请选择", //设置最顶部option的text属性
                    value:'',//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                    textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                    valueField:"key",//设置下拉框value，填写数据中对应的字段名
                    datas: result.beans,         //数据源
                    loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                    dataReady:function(){
                    }
                });
                editPriStatusSelsect.setValue('"'+editReqData.priStatus+'"');
            });
            //是否变更单选
            var radiosConfig = {
                el:$("#isChangedRadios", $el),//要绑定的容器
                className:'radio',    //组件外围的className,默认横向|all-width纵向
                disabled:0,     //是否禁用，1禁用|0不禁用
                defaultValue:'1',   //默认选中项（对应单选框的value值）
                items:[
                    {
                        className:'radio1',   //单选框的className，可不配置
                        label:'是',    //必须配置
                        value:'1',      //必须配置
                        click:function(e,itemData){
                            radios.set("1");
                        }
                    },
                    {
                        className:'radio2',
                        label:'否',
                        value:'0',
                        click:function(e,itemData){ radios.set("0") }
                    }
                ]
            };
            radios = new Radios(radiosConfig);
            radios.set(changeStatusVal)
        };
        //初始化日期
        var initDate = function() {
            //提出时间
            var proposeDate = new MyDate({
                el: $("#proposeDate", $el),
                inputClassName: 'date',
                label: '<i style="color:red;padding:2px;"></i>提出时间:',
                name: 'proposeTime',    //开始日期文本框name
                isReadOnly: true,  //项可设置日期输入框是否只读
                range: false,
                type: "date",
                isDisabled: false,//是否禁用组件
                defaultValue: editReqData.proposeTime,
                btns: ['clear', 'now', 'confirm'],
                done: function(dates,value,proposeDate){
                    planStartDate.options.min = dates; //设置开始日期的最小限制
                }
            });
            //计划开始日期
            var planStartDate = new MyDate({
                el: $("#planStartDate", $el),
                inputClassName: 'date',
                label: '<i style="color:red;padding:2px;">*</i>计划开始时间:',
                name: 'starTime',    //开始日期文本框name
                isReadOnly: true,  //项可设置日期输入框是否只读
                range: false,
                type: "date",
                isDisabled: false,//是否禁用组件
                defaultValue:editReqData.starTime,
                btns: ['now', 'confirm'],
                done: function(dates,value,planStartDate){
                    planFinishDate.options.min = dates; //设置结束日期的最小限制
                    proposeDate.options.max = dates; //设置提出日期的最大日期
                    $('input[name=likeMoreTime]').val(computeDaysDelta(dates,$('input[name=completionTime]').val())*8);//计算预估工时
                }
            });
            //计划完成日期
            var planFinishDate = new MyDate({
                el: $("#planFinishDate", $el),
                inputClassName: 'date',
                label: '<i style="color:red;padding:2px;">*</i>计划完成时间:',
                name: 'completionTime',    //开始日期文本框name
                isReadOnly: true,  //项可设置日期输入框是否只读
                min: editReqData.starTime,         //最小日期限制
                range: false,
                type: "date",
                isDisabled: false,//是否禁用组件
                defaultValue: editReqData.completionTime,
                btns: ['now', 'confirm'],
                done: function(dates,value,planFinishDate){
                    planStartDate.options.max = dates; //设置开始日期的最大日期
                    $('input[name=likeMoreTime]').val(computeDaysDelta($('input[name=starTime]').val(),dates)*8);//计算预估工时
                }
            });
        };
        //提出人提出组织
        var proposePerson = function (userId) {
            if(!userId){
                $("#presentDepartment", $el).val("");
                $("input[name='presentDepartment']", $el).val("");
                return;
            }
            Util.ajax.getJson( AjaxPath.auth+"/organs/byUser/"+ userId, {}, function(result, isok){
                if(result.returnCode==="0000") {
                    $("#presentDepartment", $el).val(result.beans.name);
                    $("input[name='presentDepartment']", $el).val(result.beans.id);
                }else{
                    $("#presentDepartment", $el).val('');
                    $("input[name='presentDepartment']", $el).val('');
                    console.log('查询组织信息异常!');
                }
            });
        };
        //多选
        var selMul = function(){
            //链接的缺陷
            Util.ajax.getJson(AjaxPath.project+'/dropdown?modual=require&type=linkInfo&name=&systemId='+editReqData.systemId+"&notRefId="+editReqData.id, {}, function(result, isok){
                editLinksToSelect = new inputTag({
                    el:$('#linksTo', $el),       //必填 要绑定的容器
                    datas: result.beans,           //必填 数据源
                    addTag: false,             //必填  是否可以添加新标签
                    textField: 'value',
                    valueField: 'key',
                    placeholder:'请输入要链接的工作项',
                });
                editLinksToSelect.checkSelectTag(editReqData.linkInfos);
            });
            //关联用例
            Util.ajax.getJson(AjaxPath.project+'/dropdown?modual=defect&type=testcase&systemId='+editReqData.systemId, {}, function(result, isok){
                relationToSelect = new inputTag({
                    el:$('#relateTo', $el),       //必填 要绑定的容器
                    datas: result.beans,           //必填 数据源
                    addTag: false,             //必填  是否可以添加新标签
                    textField: 'value',
                    valueField: 'key',
                    placeholder:'请输入要关联的用例',
                });
                relationToSelect.checkSelectTag(editReqData.relationCases, 'id');
            });
            //标签
            Util.ajax.getJson(AjaxPath.project+'/dropdown?modual=require&type=tag', {}, function(result, isok){
                editTagListSelect = new inputTag({
                    el:$('#editRequireTagList', $el),       //必填 要绑定的容器
                    datas: result.beans,           //必填 数据源
                    addTag: true,             //必填  是否可以添加新标签
                    textField: 'value',
                    valueField: 'key',
                    placeholder:'请输入标签',
                    maxlength:'20',
                });
                editTagListSelect.checkSelectTag(editReqData.tagList,'id');
            });
            //模块
            Util.ajax.getJson(AjaxPath.project+'/dropdown?modual=require&type=module&systemId='+editReqData.systemId, {}, function(result, isok){
                editModuleListSelect = new inputTag({
                    el:$('#moduleList', $el),       //必填 要绑定的容器
                    datas: result.beans,           //必填 数据源
                    addTag: false,             //必填  是否可以添加新标签
                    textField: 'value',
                    valueField: 'key',
                    placeholder:'请选择模块',
                });
                editModuleListSelect.checkSelectTag(editReqData.moduleList,'id');
            });
        };

        //附件
        var fileUp = function () {
            var uploadConfig = {
                el: $("#upload", $el), //组件绑定的容器
                className: 'upload', //组件外围的className
                url: AjaxPath.project+'/uploadFile/upload', //组件上传的后台接口
                // url: fileAjaxPath, //组件上传的后台接口
                // deleteUrl: 'data/upload.json?name=[name]', //组件上传的后台接口
                paramName:'textFile',
            };
            var filesUpload = new Upload(uploadConfig);


            filesUpload.on('submit',function(e,data){
                //formData的数据会和二进制数据一起提交到服务端
                data.formData = { creator:$cookie.get("userId"), businessType:'require', type:1 };
                // data.formData = { creator:1, businessType:'require', type:1 };
            });

            filesUpload.on('done',function(e,data){
                reqAttachmentIdList.push(data.result.files[0].attId);
            });
            filesUpload.on('remove',function(e,data){
                if(data.attId){
                    delFlag=true;
                    data=data.attId;
                };
                uploadDelete(e,data)
                //e新增自定义remove方法，可根据服务端文件处理结果删除文件列表中的当前行
            });

            filesUpload.on('download',function(e,data){
                if(data.attId){
                    delFlag=true;
                    data=data.attId;
                    uploadDown(e,data);
                };

                //e新增自定义remove方法，可根据服务端文件处理结果删除文件列表中的当前行
            });
        };

        function uploadDelete(e,data){
            //e新增自定义remove方法，可根据服务端文件处理结果删除文件列表中的当前行
            if(delFlag){
                new Dialog({
                    title: '提示', //弹窗标题，
                    content: '<div style="text-align:center;margin-top:50px">确定要删除该附件吗？</div>', //弹窗内容，可以是字符串、html代码段,tpl对象。默认为loading状态（由点组成的圈。大段代码建议使用 tpl。
                    okValue: '确&nbsp;&nbsp;定', //确定按钮的文本 默认是 ‘ok’
                    ok: function() {
                        /*Util.ajax.getJson(AjaxPath.project+'/attachment/delete/'+data, {updater:$cookie.get("userId")}, function(result, isok){
                            if(result.returnCode==='0000'){*/
                                reqAttachmentIdList = $.grep(reqAttachmentIdList,function(i,n){
                                    return i!= data;
                                });
                                e.remove();
                                /*new Dialog({
                                    mode: 'tips',
                                    delayRmove:3, //延迟删除秒数设定 tips默认3秒,非tips默认不关闭。
                                    tipsType:'tips', //tips类型；可选 success | error，默认普通tips。
                                    maxWidth:'226px', //设置tips对话框的最大宽度,默认为226px。仅在tips对话框下生效，该项存在时，width属性将失效。
                                    content: '删除附件成功！'
                                });*/
                            /*}else{
                                new Dialog({
                                    mode: 'tips',
                                    delayRmove:3, //延迟删除秒数设定 tips默认3秒,非tips默认不关闭。
                                    tipsType:'tips', //tips类型；可选 success | error，默认普通tips。
                                    maxWidth:'226px', //设置tips对话框的最大宽度,默认为226px。仅在tips对话框下生效，该项存在时，width属性将失效。
                                    content: '删除附件失败！'
                                });
                            }*/
                            return true;
                        /*});*/
                    },
                    cancel: function() {},
                    cancelValue: '取&nbsp;&nbsp;消', //取消按钮的文本 默认是 ‘关闭’
                    width: 300,
                    height: 120,
                    modal:true,
                });
            }else{
                e.remove();
            }
        };
        function uploadDown(e,data){
            //e新增自定义remove方法，可根据服务端文件处理结果删除文件列表中的当前行
            if(delFlag){
                window.location.href=AjaxPath.project+'/uploadFile/download?id='+data;
                // window.location.href= '/devops-web//uploadFile/download.do?id='+data
            }else{

            }
        };
        //filelist==del
        var fileTable = function(){
            Util.ajax.getJson(AjaxPath.project + '/attachment?businessId='+ editReqData.id +'&businessType=require', {}, function(result, isok){
                $('.files').prepend(fileList(result.beans,reqAttachmentIdList));
                $('#upload .uploadDelete').click(function(){
                    delFlag=true;
                    var delNode=$(this).parent().parent().parent('.template-upload');
                    uploadDelete(delNode,$(this).attr('data'))
                });
            })
        };

        //子工作项--日志列表
        var initList = function(){
            //子工作项列表
            editRequirementTable = new List({
                el: $('.editRequireSubTaskTable', $el),
                ajax: {    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置；慎用
                    method:'GET'
                },
                field: {
                    boxType: 'radio',
                    key: 'id',
                    items: [
                        {
                            text: '子工作项名称',
                            name: 'requireTitle',
                            className: 'w90',
                            // sorting:1,
                            width:200,
                            click: function (e, val,item) {
                                viewSubTask(e, item);
                            },
                            render: function (item, val) {
                                val = $('<span/>').text( val ).html();
                                return '<a href="javascript:;" class="text-overflow" style="line-height:36px;display:block;outline:none">' + val + '</a>';
                            }
                        },
                        {
                            text: '状态',
                            name: 'statusName',
                            className: 'w90',
                            render: function (item, val) {
                                return val;
                            }
                        },
                        {
                            text: '优先级',
                            name: 'priStatusName',
                            className: 'w90',
                            render: function (item, val) {
                                return val;
                            }
                        },
                        {
                            text: '经办人',
                            name: 'tryPeopleName',
                            className: 'w90',
                            render: function (item, val) {
                                return val;
                            }
                        },
                        {
                            text: '创建时间',
                            name: 'createTime',
                            className: 'w90',
                            render: function (item, val) {
                                return new Date(val).Format("yyyy-MM-dd hh:mm:ss");
                            }
                        },
                        {
                            text: '更新时间',
                            name: 'updateTime',
                            className: 'w90',
                            render: function (item, val) {
                                return new Date(val).Format("yyyy-MM-dd hh:mm:ss");
                            }
                        },
                        {
                            text: '操作',
                            name: '',
                            className: 'w90',
                            render: function (item, val) {
                                return '<div class="fn-center"><button class="t-btn t-btn-blue t-btn-xs editReqTableAssBtn" style="margin-right:8px;"><a style="color:#fff">分配</a></button><button class="t-btn t-btn-blue t-btn-xs editReqTableEditBtn"><a style="color:#fff">修改</a></button></div>';
                            }
                        }]
                },
                page: {
                    customPages: [2, 3, 5, 10, 15, 20, 30, 50], //可选择每页显示多少条
                    perPage: 5, //默认每页显示多少条记录
                    total: true
                },
                data: {
                    url: AjaxPath.demand + '/requires/tasks/' + editReqData.id
                    // url : 'http://192.168.91.173:8080/devops/requires/tasks/4?page=1&limit=1'
                }
            })
            editRequirementTable.search();

            //日志列表
            editReqSubTaskLogTable = new List({
                el: $('.editReqSubTaskLogList', $el),
                ajax: {    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置；慎用
                    method:'GET'
                },
                field: {
                    boxType: 'radio',
                    key: 'id',
                    items: [
                        {
                            text: '操作人',
                            name: 'createrName',
                            className: 'w90',
                            // sorting:1,
                            width:100,
                            click: function (e, val,item) {
                                // console.log(e,item)
                                // creatDialog(e, item);
                            },
                            render: function (item, val) {
                                return val;
                            }
                        },
                        {
                            text: '记录',
                            name: 'content',
                            className: 'w90 text-break',
                            width:400,
                            render: function (item, val) {
                                var str = "";
                                str += '<p class="fn-left">于&nbsp;&nbsp;' + new Date(item.createTime).Format('yyyy-MM-dd hh:mm:ss') + '&nbsp;&nbsp;' + item.typeName + '了&nbsp;&nbsp;' + item.businessType + '：' + '<a href="javascript:;" data="'+ item.businessId +'" class="viewSubTaskBtn">'+ item.businessTitle +'</a>' + item.content +'</p>';
                                return str;
                            }
                        }]
                },
                page: {
                    customPages: [2, 3, 5, 10, 15, 20, 30, 50], //可选择每页显示多少条
                    perPage: 5, //默认每页显示多少条记录
                    total: true
                },
                data: {
                    url: AjaxPath.project + '/logInfo/query?businessId='+ editReqData.id +'&businessType=require'
                }
            })
            editReqSubTaskLogTable.search();
            editReqSubTaskLogTable.on('success',function(result){
                $(".editReqSubTaskLogList" ,$el).find(".sn-list-header").hide();
            });
        };
        //工作项分配 、子工作项分配弹框
        var createReqAssDialog = function(e){
            var reqData = {};
            var editSubTaskAssSelectId = null,reqAssTitle = null;
            var who = null;
            if(e.target.className.indexOf("taskAss")>-1){
                reqData = editReqData;
                who = true;
                reqAssTitle = '工作项分配';
            }else{
                reqData = editRequirementTable.getSelected();
                who = false;
                reqAssTitle = '任务分配';
            }
            editSubTaskAssSelectId = reqData.tryPeople;

            var data = {};
            data.formClassName = "reqAndTaskForm";
            data.selectName = "editReqTaskAss";
            var config = {
                mode: 'confirm', //对话框模式，默认normal标准|tips浮动层|confirm确认对话框
                title: reqAssTitle, //对话框标题，
                content: Util.hdb.compile(taskAss)(data), //对话框内容，可以是字符串、html代码段,tpl对象。默认为loading状态（由点组成的圈。大段代码建议使用 tpl。
                ok: function() {
                    createSubTaskAss(reqData, who);
                    return true;
                },
                cancel: function() {
                    return true;
                },
                cancelValue: '取消', //取消按钮的文本 默认是 ‘关闭’
                okValue: '确定', //取消按钮的文本 默认是 ‘关闭’
                cancelDisplay: true, //是否显示取消按钮 默认true显示|false不显示
                width: 400, //对话框宽度，normal默认值为600，confirm默认值为300，tips默认值为240
                height: 200, //对话框高度，normal默认值为400，confirm默认值为180，tips默认值为80
                maxWidth: 240,//设置tips对话框的最大宽度,默认为240px。仅在tips对话框下生效，该项存在时，width属性将失效。
                maxHeight: 'auto', //设置tips对话框的最大高度,默认为auto。仅在tips对话框下生效，该项存在时，height属性将失效。
                padding:'0 16px 1em 10px',//(默认值: 继承 css 文件设置) 设置消息内容与消息容器的填充边距，即 style padding属性
                align: 'bottom left',//设置对话框与其他元素的对齐方式。仅在show(elem)与showModal(elem)传入元素时生效。默认值: "bottom left"。可选："top left" "top" "top right" "right top" "right" "right bottom" "bottom right" "bottom" "bottom left" "left bottom" "left" "left top"。
                skin: 'dialogSkin dialogSkin2',//设置对话框额外的className参数,多个className请使用空格隔开。
                fixed: false, //是否开启固定定位 默认false不开启|true开启
                quickClose: false, //点击空白处快速关闭 默认false不关闭|true关闭
                modal: true ,//是否开启模态框状态  默认false不开启|true开启,confirm默认状态为true
                backdropBackground:'#000',//设置遮罩颜色，默认 #000。
                backdropOpacity:0.7, //设置遮罩透明度，默认 0.7，取值范围：0~1 。
                beforeOpen: function() {
                    subTaskAssSelect(editSubTaskAssSelectId);
                }, //对话框打开之前执行。
                escClose:true,//esc键快速关闭对话框，默认为true
                zIndex:990   // 对话框的z-index值，默认是1024。
            };
            dialog = new Dialog(config);
        }

        var createSubTaskAss = function(datas, who){
            var data = Form.serialize($('.reqAndTaskForm'));
            data.updater = $cookie.get("userId");
            if(who){
                data.type = 1;
            }else{
                data.type = 2;
            }
            // data.updater = 1;

            Util.ajax.postJson(AjaxPath.demand + '/requires/allot/'+ datas.id, data, function(result, isok) {
                if(result.returnCode==="0000") {
                    var config = {
                        mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                        title:'提示',
                        width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                        height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                        cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                        modal:true,
                        content: '<div style="text-align:center;margin-top:50px">分配成功</div>' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
                    };
                    dialog = new Dialog(config);
                    if(who){
                        editReqData.tryPeople = result.beans.userId;
                        tryPeopleChangeSelect.setValue('"' + result.beans.userId + '"');
                    }else{
                        editRequirementTable.search({},editRequirementTable.pageIndex);
                    }
                } else {
                    var config = {
                        mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                        title:'提示',
                        width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                        height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                        cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                        modal:true,
                        content: '<div style="text-align:center;margin-top:50px">'+result.returnMessage+'</div>' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
                    };
                    dialog = new Dialog(config);
                }
            });
        };

        var subTaskAssSelect = function(id){
            editSubTaskAssSelect = new Select({
                el:$("#editReqTaskAss"),       //要绑定的容器
                ajax:{    //所有jquery.ajax的配置项均可配置，这些配置将替换底层组件的配置，<span class="s">慎用</span>
                    method:'GET'
                },
                label:'<i style="color:red;padding:2px;"></i>分配给:', //下拉框单元左侧label文本，可不配置
                selectText:false,       //是否显示  ‘选择|清除’  模式
                name:'tryPeople',    //下拉框单元右侧下拉框名称
                disabled:false,     //组件是否被禁用
                topOption:"", //设置最顶部option的text属性
                value:0,//初始选中项设置 默认是按value，如果你想按id设置 也可以 value:[&quot;id&quot;,1],这样设置
                textField:"value",   //设置下拉框内容，填写数据中对应的字段名
                valueField:"key",//设置下拉框value，填写数据中对应的字段名
                datas: tryPeopleData,         //数据源
                loadAtClick:false,// true--第一次点击时渲染|false或不配置--初始化时渲染
                dataReady:function(){
                }
            });
            editSubTaskAssSelect.setValue('"' + id + '"'); //editReqData.tryPeople
        };

        var bindEditReqSubtaskLogTab = function(){
            var data={};
            $(this).addClass('actived').siblings().removeClass('actived');
            data.type = $(this).attr("data");
            editReqSubTaskLogTable.search(data);
        }

        var bindTableSwitch = function(e){
            $(this).toggleClass('tri-left');
            $(this).parent('.t-list-title').siblings().stop().slideToggle();
        };
        
        var createReqMomeDialog = function () {
            require(['text!tpl/requirement/addMemo.tpl'], function(addMomo){
                var data = {};
                data.formClassName = "reqMemoForm";
                data.textareaName = "content";
                var config = {
                    mode: 'confirm', //对话框模式，默认normal标准|tips浮动层|confirm确认对话框
                    title: '添加备注', //对话框标题，
                    content: Util.hdb.compile(addMomo)(data), //对话框内容，可以是字符串、html代码段,tpl对象。默认为loading状态（由点组成的圈。大段代码建议使用 tpl。
                    ok: function() {
                        if(editSubTaskMomeValidor.form()) {
                            createReqMome();
                        } else {
                            console.log('验证失败');
                        }
                        return false;
                    },
                    cancel: function() {
                        return true;
                    },
                    cancelValue: '取消', //取消按钮的文本 默认是 ‘关闭’
                    okValue: '确定', //取消按钮的文本 默认是 ‘关闭’
                    cancelDisplay: true, //是否显示取消按钮 默认true显示|false不显示
                    width: 600, //对话框宽度，normal默认值为600，confirm默认值为300，tips默认值为240
                    height: 140, //对话框高度，normal默认值为400，confirm默认值为180，tips默认值为80
                    maxWidth: 240,//设置tips对话框的最大宽度,默认为240px。仅在tips对话框下生效，该项存在时，width属性将失效。
                    maxHeight: 'auto', //设置tips对话框的最大高度,默认为auto。仅在tips对话框下生效，该项存在时，height属性将失效。
                    padding:'0 16px 1em 10px',//(默认值: 继承 css 文件设置) 设置消息内容与消息容器的填充边距，即 style padding属性
                    align: 'bottom left',//设置对话框与其他元素的对齐方式。仅在show(elem)与showModal(elem)传入元素时生效。默认值: "bottom left"。可选："top left" "top" "top right" "right top" "right" "right bottom" "bottom right" "bottom" "bottom left" "left bottom" "left" "left top"。
                    skin: 'dialogSkin dialogSkin2',//设置对话框额外的className参数,多个className请使用空格隔开。
                    fixed: false, //是否开启固定定位 默认false不开启|true开启
                    quickClose: false, //点击空白处快速关闭 默认false不关闭|true关闭
                    modal: true ,//是否开启模态框状态  默认false不开启|true开启,confirm默认状态为true
                    backdropBackground:'#000',//设置遮罩颜色，默认 #000。
                    backdropOpacity:0.7, //设置遮罩透明度，默认 0.7，取值范围：0~1 。
                    beforeOpen: function() {
                        // subTaskAssSelect();
                    }, //对话框打开之前执行。
                    escClose:true,//esc键快速关闭对话框，默认为true
                    zIndex:990   // 对话框的z-index值，默认是1024。
                };
                dialog = new Dialog(config);
                createReqMomeValidation();
            })
        };
        var createReqMomeValidation = function() {
            var config = {
                // el: $('.validatorForm'),
                el: $(".reqMemoForm"),
                // submitBtn: $(".btnSave"), //触发验证的按钮，可不配置
                dialog: true, //是否弹出验证结果对话框
                rules: {
                    content: "required"
                },
                messages: {
                    content: {
                        required: "备注不能为空！"
                    }
                }
            };
            editSubTaskMomeValidor = new Validator(config);
        }
        var createReqMome = function(){
            var config = null;
            var data = Form.serialize($('.reqMemoForm'));
            data.businessId = editReqData.id;
            data.businessType = 'require';
            data.businessTitle = $("input[name='requireTitle']", $el).val();
            data.creater = $cookie.get('userId');
            Util.ajax.postJson(AjaxPath.project + '/logInfo/insert', JSON.stringify(data), function(result, isok){
                if(result.returnCode==="0000"){
                    dialog.remove();
                    editReqSubTaskLogTable.search();
                    $('.editReqTaskLogTab li').eq(0).addClass('actived').siblings().removeClass('actived');
                }else {
                    config = {
                        mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                        title:'提示',
                        width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                        height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                        cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                        modal:true,
                        content: '<div style="text-align:center;margin-top:50px">'+result.returnMessage+'</div>' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
                    };
                    dialog = new Dialog(config);
                }
            }, 'application/json')
        }

        var editRequireValidation = function() {
            editReqValidation = new Validator({
                el: $(".addRequirementForm", $el),
                submitBtn: $(".addRequireBtn"), //触发验证的按钮，可不配置
                dialog: true, //是否弹出验证结果对话框
                pattern: { numberThree: "^(\\d+\\.\\d{1,1}|\\d+)$" },
                rules: {
                    requireTitle: "required",
                    requireType: "required",
                    tryPeople: "required",
                    priStatus: "required",
                    status: "required",
                    starTime: "required",
                    completionTime: "required",
                    severity: "required",
                    likeMoreTime: "numberThree",
                    reallyUseTime: "numberThree"
                },
                messages: {
                    requireTitle: {
                        required: "工作项名称不能为空！"
                    },
                    requireType: {
                        required: "类型不能为空！"
                    },
                    tryPeople: {
                        required: "经办人不能为空！"
                    },
                    priStatus: {
                        required: "优先级不能为空！"
                    },
                    status: {
                        required: "状态不能为空！"
                    },
                    starTime: {
                        required: "计划开始时间不能为空！"
                    },
                    completionTime: {
                        required: "计划完成时间不能为空！"
                    },
                    likeMoreTime:{
                        numberThree: "此项必须为数字(非负数，可保留一位小数)！"
                    },
                    reallyUseTime:{
                        numberThree: "此项必须为数字(非负数，可保留一位小数)！"
                    },
                    severity: {
                        required: "严重程度不能为空！"
                    }
                }
            });
        };

        var saveEditRequiretValidation = function() {
            var addTag = {
                createPerson:$cookie.get("userId"),
                tags:editTagListSelect.getCheckSelectTag(),
                createModule:'require'
            };

            if(editReqValidation.form()) {
                editTagListSelectList=[];
                //创建新标签
                Util.ajax.postJson(AjaxPath.project + "/tag",JSON.stringify(addTag), function(tagResult, isok) {
                    if(tagResult.returnCode==="0000") {
                        $(tagResult.beans).each(function (index,item) {
                            editTagListSelectList.push(item.id ? item.id : item.key );
                        });
                        saveEditRequrie();
                    } else {
                        new Dialog({
                            mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                            title:'提示',
                            width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                            height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                            cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                            modal:true,
                            content: '<div style="text-align:center;margin-top:50px">'+tagResult.returnMessage+'</div>' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
                        });
                    }
                },"application/json");
            } else {
                console.log('验证失败');
            }
        };

        var saveEditRequrie = function(e) {
            var saveAddRequrieDia = null;
            var handLoading = new Loading(loadingConfig);
            var editFormReqData = Form.serialize($('.addRequirementForm', $el));
            editFormReqData.presentPeople = comboSelect.getSelected().key;
            editFormReqData.changeStatus = radios.get();
            editFormReqData.linkIdAndTypes = editLinksToSelect.getCheckSelectTag('key');
            editFormReqData.tagIdList = editTagListSelectList;
            editFormReqData.moduleIdList = editModuleListSelect.getCheckSelectTag('key');
            editFormReqData.attachmentIdList = reqAttachmentIdList;
            editFormReqData.systemId = editReqData.systemId;
            editFormReqData.updater=$cookie.get("userId");
            if(editReqType.getSelected().key === 4){
                editFormReqData.discoverySprint = findSprintsChangeSelect.getSelected().key;
                editFormReqData.importStatus = severityReq.getSelected().key;
                editFormReqData.status = defectstatusChangeSelect.getSelected().key;
                editFormReqData.relationCaseIds = relationToSelect.getCheckSelectTag('key');
            }else{
                editFormReqData.status = statusChangeSelect.getSelected().key;
            }
            editFormReqData.defectReason = defectReason.getSelected().key;
            editFormReqData.requireType = editReqData.requireType;
            var saveAddRequrieDiaConfig = {
                mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                title:'提示',
                width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                modal:true,
                content: '' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
            };

            Util.ajax.postJson(AjaxPath.demand+"/requires/"+editReqData.id, JSON.stringify(editFormReqData), function(result, isok) {
                handLoading.destroy();
                if(result.returnCode==="0000") {
                    saveAddRequrieDiaConfig.content = '<div style="text-align:center;margin-top:50px">'+result.returnMessage+'</div>'
                    saveAddRequrieDia = new Dialog(saveAddRequrieDiaConfig);
                    saveAddRequrieDia.on('onclose',function(){
                        back();
                    });
                } else {
                    saveAddRequrieDiaConfig.content = '<div style="text-align:center;margin-top:50px">'+result.returnMessage+'</div>'
                    saveAddRequrieDia = new Dialog(saveAddRequrieDiaConfig);
                }
            },"application/json");
        };

        var getEditReqData = function(){
            Util.ajax.getJson(AjaxPath.demand + '/requires/'+ editReqData.id +'?type=1', {}, function(result, isok){
                if(result.returnCode==="0000"){
                    editReqData = result.beans;
                    formInit();
                    inSelect();
                    initDate();
                    // proposePerson();
                    fileUp();
                    selMul();
                    fileTable();//修改时用
                    initList();
                    getEditTaskNextStatus(editReqData.status);
                    editRequireValidation();
                }else {
                    new Dialog({
                        mode: 'confirm', // 对话框模式，默认normal标准|confirm浮动层|confirm确认对话框
                        title:'提示',
                        width: 300, //对话框宽度，可选项。normal默认值为600，confirm默认值为300，tips默认值为240
                        height: 120, //对话框高度，可选项。normal默认值为400，confirm默认值为180，tips默认值为80
                        cancelDisplay: false, //是否显示取消按钮（强制执行，可在confirm模式下生效），可选项。 默认true(显示)
                        modal:true,
                        content: '<div style="text-align:center;margin-top:50px">'+result.returnMessage+'</div>' ,// 对话框内容，可以是字符串、html片段、或dom对象,默认为loading状态（点组成的圈）
                    });
                }
            });
        }

        var createLoading = function(){
            loadingConfig = {
                el:'body',                  //组件要绑定的容器，默认为body（此项可不配置或留空）
                className:'loading',           //组件外围的className
                position:'center',      //提示信息位置，顶部top|默认center中央
                width:'300',      //loading的宽度,非必须，默认300
                height:'auto',      //loading的宽度,非必须，默认auto
                mask:1,                 //是否显示遮罩， 0不显示|默认1显示
                animate:1,              //是否显示动画效果， 0不显示|默认1显示
                mode:'layer',     //展示方式 loadingLine线条方式|默认layer弹层方式
                text:'加载中...',       //提示文字，默认 加载中...
                icon:'dotCycle',  //文字前面的gif动画， 默认dotCycle有点组成的圈|cmcc移动图标|cmccLarge大的移动图标
            }
        };

        var judgeRequireType = function(){
            if(editReqData.requireType === "4"){
                $(".defectShow", $el).show();
                $(".defectHide", $el).hide();
                $("#statusList", $el).remove();
            } else {
                $(".defectShow", $el).hide();
                $(".defectHide", $el).show();
                $("#severityReq", $el).remove();
                $("#defectStatusList", $el).remove();
            }
        }
        return initialize;

    });

